టెంప్లేట్ లిటరల్ టైప్స్: టైప్‌స్క్రిప్ట్‌లో స్ట్రింగ్ ప్యాటర్న్ మ్యాచింగ్ మరియు వాలిడేషన్

టైప్‌స్క్రిప్ట్ యొక్క టైప్ సిస్టమ్ నిరంతరం అభివృద్ధి చెందుతోంది, సంక్లిష్ట లాజిక్‌ను వ్యక్తీకరించడానికి మరియు టైప్ సేఫ్టీని నిర్ధారించడానికి డెవలపర్‌లకు మరింత శక్తివంతమైన సాధనాలను అందిస్తుంది. ఇటీవలి వెర్షన్‌లలో ప్రవేశపెట్టిన అత్యంత ఆసక్తికరమైన మరియు బహుముఖ లక్షణాలలో ఒకటి టెంప్లేట్ లిటరల్ టైప్స్. ఈ టైప్‌లు మీరు టైప్ స్థాయిలో స్ట్రింగ్‌లను మార్చడానికి, అధునాతన స్ట్రింగ్ ప్యాటర్న్ మ్యాచింగ్ మరియు వాలిడేషన్‌ను ప్రారంభించడానికి అనుమతిస్తాయి. ఇది మరింత పటిష్టమైన మరియు నిర్వహించదగిన అప్లికేషన్‌లను రూపొందించడానికి సరికొత్త అవకాశాల ప్రపంచాన్ని తెరుస్తుంది.

టెంప్లేట్ లిటరల్ టైప్స్ అంటే ఏమిటి?

టెంప్లేట్ లిటరల్ టైప్‌లు స్ట్రింగ్ లిటరల్ టైప్‌లు మరియు యూనియన్ టైప్‌లను కలపడం ద్వారా నిర్మించబడిన ఒక రకమైన టైప్, జావాస్క్రిప్ట్‌లో టెంప్లేట్ లిటరల్స్ ఎలా పనిచేస్తాయో అదే విధంగా. అయితే, రన్‌టైమ్ స్ట్రింగ్‌లను సృష్టించే బదులు, అవి ఇప్పటికే ఉన్న వాటి ఆధారంగా కొత్త టైప్‌లను సృష్టిస్తాయి.

ఇక్కడ ఒక ప్రాథమిక ఉదాహరణ:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // type MyGreeting = "Hello, World!"

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, `Greeting` అనేది ఒక టెంప్లేట్ లిటరల్ టైప్, ఇది స్ట్రింగ్ టైప్ `T`ని ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు "Hello, ", `T` మరియు "!" ల కన్కాటెనేషన్ అయిన కొత్త టైప్‌ను తిరిగి ఇస్తుంది.

ప్రాథమిక స్ట్రింగ్ ప్యాటర్న్ మ్యాచింగ్

టెంప్లేట్ లిటరల్ టైప్‌లను ప్రాథమిక స్ట్రింగ్ ప్యాటర్న్ మ్యాచింగ్‌ను నిర్వహించడానికి ఉపయోగించవచ్చు. ఇది ఒక నిర్దిష్ట ప్యాటర్న్‌కు సరిపోలితే మాత్రమే చెల్లుబాటు అయ్యే టైప్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఉదాహరణకు, మీరు "prefix-"తో ప్రారంభమయ్యే స్ట్రింగ్‌లను మాత్రమే అంగీకరించే టైప్‌ను సృష్టించవచ్చు:

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, `PrefixedString` ఇన్‌పుట్ స్ట్రింగ్ `T` "prefix-"తో ప్రారంభమవుతుందో లేదో తనిఖీ చేయడానికి కండిషనల్ టైప్‌ను ఉపయోగిస్తుంది. అలా అయితే, టైప్ `T`; లేకపోతే, అది `never`. `never` అనేది టైప్‌స్క్రిప్ట్‌లో ప్రత్యేకమైన టైప్, ఇది ఎప్పుడూ జరగని విలువల రకాన్ని సూచిస్తుంది, ఇది చెల్లని స్ట్రింగ్‌ను సమర్థవంతంగా మినహాయిస్తుంది.

స్ట్రింగ్ భాగాలను సంగ్రహించడం

టెంప్లేట్ లిటరల్ టైప్‌లను స్ట్రింగ్ భాగాలను సంగ్రహించడానికి కూడా ఉపయోగించవచ్చు. స్ట్రింగ్‌ల నుండి డేటాను పార్స్ చేసి, దానిని విభిన్న టైప్‌లుగా మార్చాల్సిన అవసరం వచ్చినప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.

మీరు "x:10,y:20" ఆకృతిలో ఒక కోఆర్డినేట్‌ను సూచించే స్ట్రింగ్‌ను కలిగి ఉన్నారని అనుకుందాం. మీరు x మరియు y విలువల కోసం టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించవచ్చు:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, `ExtractX` మరియు `ExtractY` `infer` కీవర్డ్‌ను ఉపయోగించి `number` టైప్‌కు సరిపోయే స్ట్రింగ్ భాగాలను క్యాప్చర్ చేస్తాయి. `infer` ఒక ప్యాటర్న్ మ్యాచ్ నుండి ఒక టైప్‌ను సంగ్రహించడానికి మిమ్మల్ని అనుమతిస్తుంది. క్యాప్చర్ చేయబడిన టైప్‌లు కండిషనల్ టైప్ యొక్క రిటర్న్ టైప్‌గా ఉపయోగించబడతాయి.

అడ్వాన్స్‌డ్ స్ట్రింగ్ వాలిడేషన్

టెంప్లేట్ లిటరల్ టైప్‌లను ఇతర టైప్‌స్క్రిప్ట్ లక్షణాలతో, అంటే యూనియన్ టైప్‌లు మరియు కండిషనల్ టైప్‌లతో కలిపి, అధునాతన స్ట్రింగ్ వాలిడేషన్‌ను నిర్వహించడానికి ఉపయోగించవచ్చు. ఇది స్ట్రింగ్‌ల నిర్మాణం మరియు కంటెంట్‌పై సంక్లిష్ట నియమాలను అమలు చేసే టైప్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఉదాహరణకు, మీరు ISO 8601 డేట్ స్ట్రింగ్‌లను ధృవీకరించే టైప్‌ను సృష్టించవచ్చు:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

ఇక్కడ, `Year`, `Month` మరియు `Day` టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించి నిర్వచించబడ్డాయి, ఇవి తేదీలోని ప్రతి భాగానికి చెల్లుబాటు అయ్యే ఫార్మాట్‌లను సూచిస్తాయి. `ISODate` ఈ టైప్‌లను కలిపి, చెల్లుబాటు అయ్యే ISO 8601 డేట్ స్ట్రింగ్‌ను సూచించే టైప్‌ను సృష్టిస్తుంది. ఈ టైప్‌ను ఫంక్షన్‌లో డేటా ఫార్మాటింగ్‌ను అమలు చేయడానికి ఎలా ఉపయోగించవచ్చో ఉదాహరణ కూడా వివరిస్తుంది, తద్వారా తప్పు డేట్ ఫార్మాట్‌లు పాస్ చేయబడకుండా నిరోధిస్తుంది. ఇది కోడ్ విశ్వసనీయతను మెరుగుపరుస్తుంది మరియు చెల్లని ఇన్‌పుట్ వల్ల కలిగే రన్‌టైమ్ లోపాలను నివారిస్తుంది.

వాస్తవ-ప్రపంచ వినియోగ సందర్భాలు

టెంప్లేట్ లిటరల్ టైప్‌లను వివిధ వాస్తవ-ప్రపంచ సందర్భాలలో ఉపయోగించవచ్చు. ఇక్కడ కొన్ని ఉదాహరణలు:

• ఫారం వాలిడేషన్: ఇమెయిల్ అడ్రస్‌లు, ఫోన్ నంబర్‌లు మరియు పోస్టల్ కోడ్‌ల వంటి ఫారం ఇన్‌పుట్‌ల ఆకృతిని ధృవీకరించడానికి మీరు టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించవచ్చు.
• API అభ్యర్థన వాలిడేషన్: API అభ్యర్థన పేలోడ్‌ల నిర్మాణాన్ని ధృవీకరించడానికి మీరు టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించవచ్చు, అవి ఆశించిన ఆకృతికి అనుగుణంగా ఉన్నాయని నిర్ధారిస్తుంది. ఉదాహరణకు, కరెన్సీ కోడ్‌ను ధృవీకరించడం (ఉదా., "USD", "EUR", "GBP").
• కాన్ఫిగరేషన్ ఫైల్ పార్సింగ్: కాన్ఫిగరేషన్ ఫైల్‌లను పార్స్ చేయడానికి మరియు నిర్దిష్ట ప్యాటర్న్‌ల ఆధారంగా విలువలను సంగ్రహించడానికి మీరు టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించవచ్చు. కాన్ఫిగరేషన్ ఆబ్జెక్ట్‌లో ఫైల్ మార్గాలను ధృవీకరించడాన్ని పరిగణించండి.
• స్ట్రింగ్-ఆధారిత ఎనమ్‌లు: మీరు టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించి వాలిడేషన్‌తో స్ట్రింగ్-ఆధారిత ఎనమ్‌లను సృష్టించవచ్చు.

ఉదాహరణ: కరెన్సీ కోడ్‌లను ధృవీకరించడం

కరెన్సీ కోడ్‌లను ధృవీకరించడానికి మరింత వివరణాత్మక ఉదాహరణను చూద్దాం. మా అప్లికేషన్‌లో చెల్లుబాటు అయ్యే ISO 4217 కరెన్సీ కోడ్‌లను మాత్రమే ఉపయోగించబడుతున్నాయని మేము నిర్ధారించుకోవాలి. ఈ కోడ్‌లు సాధారణంగా మూడు పెద్ద అక్షరాలు.

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

ఈ ఉదాహరణ మూడు పెద్ద అక్షరాలతో కూడిన స్ట్రింగ్‌లను మాత్రమే అంగీకరించే `CurrencyCode` టైప్‌ను ఎలా సృష్టించాలో వివరిస్తుంది. రెండవ, మరింత స్ట్రాంగ్లీ-టైప్ చేయబడిన ఉదాహరణ, ఆమోదయోగ్యమైన కరెన్సీల ముందే నిర్వచించిన జాబితాకు దీనిని మరింత ఎలా పరిమితం చేయాలో చూపిస్తుంది.

ఉదాహరణ: API ఎండ్‌పాయింట్ మార్గాలను ధృవీకరించడం

మరొక వినియోగ సందర్భం API ఎండ్‌పాయింట్ మార్గాలను ధృవీకరించడం. మీరు చెల్లుబాటు అయ్యే API ఎండ్‌పాయింట్ నిర్మాణాన్ని సూచించే టైప్‌ను నిర్వచించవచ్చు, అభ్యర్థనలు సరైన మార్గాలకు చేయబడుతున్నాయని నిర్ధారిస్తుంది. బహుళ సేవలు విభిన్న APIలను బహిర్గతం చేసే మైక్రోసర్వీసెస్ ఆర్కిటెక్చర్లలో ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

ఇది API ఎండ్‌పాయింట్‌ల నిర్మాణాన్ని మరింత ఖచ్చితంగా నిర్వచించడానికి, టైపోలను నిరోధించడానికి మరియు మీ అప్లికేషన్ అంతటా స్థిరత్వాన్ని నిర్ధారించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది ఒక ప్రాథమిక ఉదాహరణ; క్వెరీ పారామితులు మరియు URLలోని ఇతర భాగాలను ధృవీకరించడానికి మరింత సంక్లిష్టమైన నమూనాలను సృష్టించవచ్చు.

టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు

స్ట్రింగ్ ప్యాటర్న్ మ్యాచింగ్ మరియు వాలిడేషన్ కోసం టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించడం అనేక ప్రయోజనాలను అందిస్తుంది:

• మెరుగైన టైప్ సేఫ్టీ: టెంప్లేట్ లిటరల్ టైప్‌లు స్ట్రింగ్‌లపై కఠినమైన టైప్ పరిమితులను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తాయి, రన్‌టైమ్ లోపాల ప్రమాదాన్ని తగ్గిస్తాయి.
• మెరుగైన కోడ్ రీడబిలిటీ: టెంప్లేట్ లిటరల్ టైప్‌లు స్ట్రింగ్‌ల యొక్క ఆశించిన ఆకృతిని స్పష్టంగా వ్యక్తీకరించడం ద్వారా మీ కోడ్‌ను మరింత చదవగలిగేలా చేస్తాయి.
• నిర్వహణ సామర్థ్యం పెంపు: స్ట్రింగ్ వాలిడేషన్ నియమాలకు ఒకే విశ్వసనీయ మూలాన్ని అందించడం ద్వారా టెంప్లేట్ లిటరల్ టైప్‌లు మీ కోడ్‌ను మరింత నిర్వహించదగినదిగా చేస్తాయి.
• మెరుగైన డెవలపర్ అనుభవం: టెంప్లేట్ లిటరల్ టైప్‌లు మెరుగైన ఆటోకంప్లీషన్ మరియు ఎర్రర్ సందేశాలను అందిస్తాయి, మొత్తం డెవలపర్ అనుభవాన్ని మెరుగుపరుస్తాయి.

పరిమితులు

టెంప్లేట్ లిటరల్ టైప్‌లు శక్తివంతమైనవి అయినప్పటికీ, వాటికి కొన్ని పరిమితులు కూడా ఉన్నాయి:

• సంక్లిష్టత: టెంప్లేట్ లిటరల్ టైప్‌లు సంక్లిష్టంగా మారవచ్చు, ముఖ్యంగా సంక్లిష్ట నమూనాలతో వ్యవహరించేటప్పుడు. టైప్ సేఫ్టీ ప్రయోజనాలను కోడ్ నిర్వహణ సామర్థ్యంతో సమతుల్యం చేయడం చాలా ముఖ్యం.
• పనితీరు: టెంప్లేట్ లిటరల్ టైప్‌లు కంపైలేషన్ పనితీరును ప్రభావితం చేయగలవు, ముఖ్యంగా పెద్ద ప్రాజెక్టులలో. ఎందుకంటే టైప్‌స్క్రిప్ట్ మరింత సంక్లిష్టమైన టైప్ తనిఖీని నిర్వహించవలసి ఉంటుంది.
• పరిమిత రెగ్యులర్ ఎక్స్‌ప్రెషన్ మద్దతు: టెంప్లేట్ లిటరల్ టైప్‌లు ప్యాటర్న్ మ్యాచింగ్‌ను అనుమతించినప్పటికీ, అవి రెగ్యులర్ ఎక్స్‌ప్రెషన్ లక్షణాల పూర్తి శ్రేణికి మద్దతు ఇవ్వవు. అత్యంత సంక్లిష్టమైన స్ట్రింగ్ వాలిడేషన్ కోసం, సరైన ఇన్‌పుట్ శానిటైజేషన్ కోసం ఈ టైప్ కన్‌స్ట్రక్ట్‌లతో పాటు రన్‌టైమ్ రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లు ఇప్పటికీ అవసరం కావచ్చు.

ఉత్తమ పద్ధతులు

టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగిస్తున్నప్పుడు గుర్తుంచుకోవలసిన కొన్ని ఉత్తమ పద్ధతులు ఇక్కడ ఉన్నాయి:

• సరళంగా ప్రారంభించండి: సరళమైన ప్యాటర్న్‌లతో ప్రారంభించండి మరియు అవసరమైన విధంగా సంక్లిష్టతను క్రమంగా పెంచండి.
• వివరణాత్మక పేర్లను ఉపయోగించండి: కోడ్ రీడబిలిటీని మెరుగుపరచడానికి మీ టెంప్లేట్ లిటరల్ టైప్‌ల కోసం వివరణాత్మక పేర్లను ఉపయోగించండి.
• మీ టైప్‌లను డాక్యుమెంట్ చేయండి: మీ టెంప్లేట్ లిటరల్ టైప్‌ల ఉద్దేశ్యం మరియు వినియోగాన్ని వివరించడానికి వాటిని డాక్యుమెంట్ చేయండి.
• షుణ్ణంగా పరీక్షించండి: మీ టెంప్లేట్ లిటరల్ టైప్‌లు ఆశించిన విధంగా పనిచేస్తాయని నిర్ధారించుకోవడానికి వాటిని క్షుణ్ణంగా పరీక్షించండి.
• పనితీరును పరిగణించండి: కంపైలేషన్ పనితీరుపై టెంప్లేట్ లిటరల్ టైప్‌ల ప్రభావాన్ని గుర్తుంచుకోండి మరియు తదనుగుణంగా మీ కోడ్‌ను ఆప్టిమైజ్ చేయండి.

ముగింపు

టెంప్లేట్ లిటరల్ టైప్‌లు టైప్‌స్క్రిప్ట్‌లో ఒక శక్తివంతమైన లక్షణం, ఇది టైప్ స్థాయిలో అధునాతన స్ట్రింగ్ మానిప్యులేషన్, ప్యాటర్న్ మ్యాచింగ్ మరియు వాలిడేషన్‌ను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది. టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించడం ద్వారా, మీరు మరింత పటిష్టమైన, నిర్వహించదగిన మరియు టైప్-సేఫ్ అప్లికేషన్‌లను సృష్టించవచ్చు. వాటికి కొన్ని పరిమితులు ఉన్నప్పటికీ, టెంప్లేట్ లిటరల్ టైప్‌లను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు తరచుగా లోపాలను అధిగమిస్తాయి, ఇది ఏదైనా టైప్‌స్క్రిప్ట్ డెవలపర్ ఆయుధాగారంలో విలువైన సాధనంగా మారుతుంది. టైప్‌స్క్రిప్ట్ భాష అభివృద్ధి చెందుతున్నందున, అధిక-నాణ్యత సాఫ్ట్‌వేర్‌ను రూపొందించడానికి ఈ అధునాతన టైప్ లక్షణాలను అర్థం చేసుకోవడం మరియు ఉపయోగించడం చాలా కీలకం. సంక్లిష్టతను రీడబిలిటీతో సమతుల్యం చేసుకోవాలని మరియు ఎల్లప్పుడూ క్షుణ్ణమైన పరీక్షకు ప్రాధాన్యత ఇవ్వాలని గుర్తుంచుకోండి.